/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package net.etrs.formathlon.vue.jsf.form.user;

import java.util.ArrayList;
import java.util.List;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import net.etrs.formathlon.control.exception.ExceptionManager;
import net.etrs.formathlon.entity.formation.Inscription;
import net.etrs.formathlon.metier.exception.MetierException;
import net.etrs.formathlon.persistance.formation.InscriptionFacade;
import net.etrs.formathlon.persistance.formation.SessionFacade;
import net.etrs.formathlon.vue.jsf.utils.Confirmable;
import net.etrs.formathlon.vue.jsf.utils.GeneralBean;

/**
 * ManageBean JSF pour les pages traitant de l'administration des inscriptions.
 * @author OPIF
 */
@ManagedBean
@ViewScoped
public class UserInscriptionBean extends GeneralBean implements Confirmable {

    @EJB
    private InscriptionFacade inscriptionFacade;
    @EJB
    private SessionFacade sessionFacade;
    private List<Inscription> listInscription;
    private List<Inscription> listInscriptionSub = new ArrayList<Inscription>();
    private Inscription inscription;
    private TypeAction actionEnCours = null;
    private String motif;

    /**
     * constructeur par defaut.
     */
    public UserInscriptionBean() {
        listInscription = new ArrayList<Inscription>();
    }

    /**
     * Action de suppression.
     * @param inscription 
     */
    public void supprimer(Inscription inscription) {
        this.inscription = inscription;
        this.actionEnCours = TypeAction.SUPPRESSION;
        getConfirmationBean().open(this, getMessage("application.UserInscriptionBean.supprimer"));
    }

    /**
     * Permet de savoir si une inscription peut être annuler.
     * @param inscription
     * @return vrai ou faux
     */
    public boolean canAnnuler(Inscription inscription) {
        return inscription.isAnnulable();
    }

    /**
     * Permet de savoir si une inscription peut être supprimer.
     * @param inscription
     * @return vrai ou faux
     */
    public boolean canSupprimer(Inscription inscription) {
        return inscription.isSupprimable();
    }

    /**
     * Permet de savoir si un utilisateur peut se desister d une formation.
     * @param inscription
     * @return vrai ou faux
     */
    public boolean canDesister(Inscription inscription) {
        return inscription.isDesistable();
    }

    /**
     * Retour de confirmation. La demande est acceptée.
     * Ne peut être que pour un verrouillage.
     */
    @Override
    public void confirmer() {
        switch (actionEnCours) {
            case ANNULATION:
                validerAnnulation();
                break;
            case SUPPRESSION:
                validerSupprimer();
                break;
        }
    }

    /**
     * Methode permettant une annulation de la part d un personnel.
     */
    public void validerDesister() {
        try {
            inscriptionFacade.desister(inscription, motif);
            if (sessionFacade.isFermee(inscription.getSession())) {
                sessionFacade.desistement(inscription);
            }
            displayMessage(getMessage("application.UserInscriptionBean.validerDesister"));
        } catch (MetierException ex) {
            displayErreur(ExceptionManager.traiter(ex));
        }
    }

    /**
     * Methode pour supprimer une inscription.
     */
    private void validerSupprimer() {
        try {
            inscriptionFacade.supprimer(inscription);
            displayMessage(getMessage("application.UserInscriptionBean.validerSupprimer"));
        } catch (MetierException ex) {
            displayErreur(ExceptionManager.traiter(ex));
        }
    }

    /**
     * Methode pour annuler une inscription.
     */
    private void validerAnnulation() {
        try {
            inscriptionFacade.annuler(inscription);
            displayMessage(getMessage("application.UserInscriptionBean.validerAnnulation"));
        } catch (MetierException ex) {
            displayErreur(ExceptionManager.traiter(ex));
        }
    }

    /**
     * Retour de confirmation. La demande est annulée.
     */
    @Override
    public void infirmer() {
    }

    /**
     * @return the listInscription.
     */
    public List<Inscription> getListInscription() {
        return inscriptionFacade.getListInscriptionPourUnFormateur(getLoginControler().getUtilisateurConnecte().getPersonnel());
    }

    /**
     * @return the listInscriptionSub.
     */
    public List<Inscription> getListInscriptionSub() {
        try {
            return inscriptionFacade.getInscriptionSub(getLoginControler().getUtilisateurConnecte());
        } catch (MetierException ex) {
            displayErreur(ExceptionManager.traiter(ex));
            return new ArrayList<Inscription>();
        }
    }

    /**
     * @return the inscription.
     */
    public Inscription getInscription() {
        return inscription;
    }

    /**
     * @param inscription the inscription to set
     */
    public void setInscription(Inscription inscription) {
        this.inscription = inscription;
    }

    /**
     * Méthode appelé permettant d'exécuter le popup annulation.
     * @param inscription 
     */
    public void annuler(Inscription inscription) {
        this.inscription = inscription;
        this.actionEnCours = TypeAction.ANNULATION;
        getConfirmationBean().open(this, getMessage("application.UserInscriptionBean.annuler"));
    }

    /**
     * Retour de la popup par le bouton annuler
     */
    public void annuler() {
    }

    /**
     * Méthode appelé permettant d'exécuter le popup annulation.
     * @param inscription 
     */
    public void desister(Inscription inscription) {
        this.inscription = inscription;
        getPopupBean().open(getMessage("application.UserInscriptionBean.saisirMotif"));
    }

    /**
     * Enumération sur le type d'action.
     */
    private enum TypeAction {
        SUPPRESSION, ANNULATION;
    }

    /**
     * 
     * @return motif
     */
    public String getMotif() {
        return motif;
    }

    /**
     * 
     * @param motif 
     */
    public void setMotif(String motif) {
        this.motif = motif;
    }
}
